import { ElMessage } from 'element-plus'
import { api } from  '@/utils/api'
import type { UploadFile } from '@/types/admin'
import { config, fileConfig, apiEndpoints } from '@/config'

/**
 * 验证图片文件
 */
export const validateImageFile = (file: File): { valid: boolean; message?: string } => {
  // 检查文件类型
  if (!fileConfig.supportedImageTypes.includes(file.type)) {
    return {
      valid: false,
      message: '不支持的图片格式，请上传 JPG、PNG、GIF 或 WebP 格式的图片'
    }
  }

  // 检查文件大小
  if (file.size > fileConfig.maxFileSize) {
    return {
      valid: false,
      message: `图片大小不能超过 ${Math.round(fileConfig.maxFileSize / 1024 / 1024)}MB`
    }
  }

  return { valid: true }
}

/**
 * 上传单个图片
 */
export const uploadImage = async (file: File): Promise<string> => {
  const formData = new FormData()
  formData.append('image', file)

  try {
    const response = await fetch(config.uploadUrl, {
      method: 'POST',
      body: formData,
    })

    if (!response.ok) {
      throw new Error('上传失败')
    }

    const result = await response.json()
    // 后端返回的数据结构是 { message: '...', data: { url: '...', ... } }
    return result.data?.url || result.url
  } catch (error) {
    console.error('上传图片失败:', error)
    throw error
  }
}

/**
 * 上传多个图片
 */
export const uploadMultipleImages = async (files: File[]): Promise<UploadFile[]> => {
  if (files.length === 0) {
    throw new Error('请选择要上传的图片')
  }

  if (files.length > fileConfig.maxUploadCount) {
    throw new Error(`最多只能同时上传${fileConfig.maxUploadCount}张图片`)
  }

  // 验证所有文件
  for (const file of files) {
    const validation = validateImageFile(file)
    if (!validation.valid) {
      throw new Error(`${file.name}: ${validation.message}`)
    }
  }

  // 创建 FormData
  const formData = new FormData()
  files.forEach(file => {
    formData.append('files', file)
  })

  try {
    const response = await api.upload<UploadFile[]>(apiEndpoints.UPLOAD_MULTIPLE, formData)
    
    if (response.data && Array.isArray(response.data)) {
      return response.data
    } else {
      throw new Error('上传失败，服务器未返回文件信息')
    }
  } catch (error: any) {
    console.error('批量图片上传失败:', error)
    
    if (error.response) {
      const { status, data } = error.response
      throw new Error(data.error || '批量图片上传失败')
    } else if (error.request) {
      throw new Error('网络请求失败，请检查网络连接')
    } else {
      throw new Error(error.message || '批量图片上传失败')
    }
  }
}

/**
 * 删除图片
 */
export const deleteImage = async (filename: string): Promise<void> => {
  try {
    await api.delete(`${apiEndpoints.UPLOAD_IMAGES}/${filename}`)
  } catch (error: any) {
    console.error('删除图片失败:', error)
    
    if (error.response) {
      const { status, data } = error.response
      
      switch (status) {
        case 404:
          throw new Error('图片不存在')
        case 403:
          throw new Error('没有权限删除此图片')
        default:
          throw new Error(data.error || '删除图片失败')
      }
    } else {
      throw new Error('删除图片失败')
    }
  }
}

/**
 * 获取图片列表
 */
export const getImageList = async (): Promise<UploadFile[]> => {
  try {
    const response = await api.get<UploadFile[]>(`${apiEndpoints.UPLOAD}/list/images`)
    return response.data || []
  } catch (error: any) {
    console.error('获取图片列表失败:', error)
    throw new Error('获取图片列表失败')
  }
}

/**
 * 预览图片URL
 */
export const getImagePreviewUrl = (url: string): string => {
  if (!url) return ''
  
  // 如果已经是完整URL，直接返回
  if (url.startsWith('http://') || url.startsWith('https://')) {
    return url
  }
  
  // 确保URL格式正确
  const cleanUrl = url.startsWith('/') ? url : '/' + url
  return `${config.uploadBaseUrl}${cleanUrl}`
}

/**
 * 获取图片代理URL（解决跨域问题）
 */
export const getProxiedImageUrl = (url: string): string => {
  if (!url) return ''
  
  // 如果是开发环境，使用代理
  if (import.meta.env.DEV) {
    // 如果URL已经是完整的HTTP路径，需要转换为代理路径
    if (url.startsWith('http://') || url.startsWith('https://')) {
      // 提取路径部分
      try {
        const urlObj = new URL(url)
        return urlObj.pathname
      } catch {
        return url
      }
    }
    
    // 如果是相对路径，直接返回（Vite会自动处理）
    return url.startsWith('/') ? url : '/' + url
  }
  
  // 生产环境返回完整URL
  return getImagePreviewUrl(url)
}

/**
 * 获取图片缩略图URL
 * @param url 原图URL
 * @param size 缩略图尺寸
 * @returns 缩略图URL
 */
export const getImageThumbnailUrl = (url: string, size: 'small' | 'medium' | 'large' = 'medium'): string => {
  const fullUrl = getImagePreviewUrl(url)
  if (!fullUrl) return ''
  
  // 如果后端支持缩略图，可以添加查询参数
  const sizeMap = {
    small: '150x100',
    medium: '300x200',
    large: '600x400'
  }
  
  // 这里可以根据后端API调整
  return `${fullUrl}?thumbnail=${sizeMap[size]}`
}

/**
 * 检查图片是否可访问
 * @param url 图片URL
 * @returns Promise<boolean>
 */
export const checkImageAccessibility = (url: string): Promise<boolean> => {
  return new Promise((resolve) => {
    const img = new Image()
    img.onload = () => resolve(true)
    img.onerror = () => resolve(false)
    img.src = getImagePreviewUrl(url)
    
    // 设置超时
    setTimeout(() => resolve(false), 5000)
  })
}

/**
 * 获取图片信息
 * @param url 图片URL
 * @returns Promise<{width: number, height: number, size?: number}>
 */
export const getImageInfo = (url: string): Promise<{width: number, height: number}> => {
  return new Promise((resolve, reject) => {
    const img = new Image()
    img.onload = () => {
      resolve({
        width: img.naturalWidth,
        height: img.naturalHeight
      })
    }
    img.onerror = () => reject(new Error('图片加载失败'))
    img.src = getImagePreviewUrl(url)
  })
}

/**
 * 从文件输入元素获取文件
 * @param input 文件输入元素
 * @returns 文件数组
 */
export const getFilesFromInput = (input: HTMLInputElement): File[] => {
  if (!input.files) return []
  return Array.from(input.files)
}

/**
 * 创建图片预览URL
 * @param file 文件对象
 * @returns 预览URL
 */
export const createImagePreview = (file: File): string => {
  return URL.createObjectURL(file)
}

/**
 * 释放图片预览URL
 * @param url 预览URL
 */
export const revokeImagePreview = (url: string): void => {
  URL.revokeObjectURL(url)
}

/**
 * 获取完整的图片URL（用于后端验证）
 * @param url 图片URL
 * @returns 完整的图片URL
 */
export const getFullImageUrl = (url: string): string => {
  if (!url) return ''
  
  // 如果已经是完整URL，直接返回
  if (url.startsWith('http://') || url.startsWith('https://')) {
    return url
  }
  
  // 使用统一的配置
  const uploadBaseUrl = config.uploadBaseUrl
  
  // 确保URL格式正确
  const cleanUrl = url.startsWith('/') ? url : '/' + url
  return `${uploadBaseUrl}${cleanUrl}`
}

/**
 * 验证图片URL格式
 * @param url 图片URL
 * @returns 是否为有效URL
 */
export const validateImageUrl = (url: string): boolean => {
  if (!url) return false
  
  try {
    // 如果是相对路径，转换为完整URL后验证
    const fullUrl = url.startsWith('http') ? url : getFullImageUrl(url)
    new URL(fullUrl)
    return true
  } catch {
    return false
  }
}

/**
 * 上传文件（通用方法）
 */
export const uploadFile = async (file: File, type: 'image' | 'video' | 'document' = 'image'): Promise<string> => {
  const formData = new FormData()
  formData.append('file', file)
  formData.append('type', type)

  try {
    const response = await fetch(`${config.apiBaseUrl}${apiEndpoints.UPLOAD}/${type}`, {
      method: 'POST',
      body: formData,
    })

    if (!response.ok) {
      throw new Error('上传失败')
    }

    const result = await response.json()
    // 后端返回的数据结构是 { message: '...', data: { url: '...', ... } }
    return result.data?.url || result.url
  } catch (error) {
    console.error('上传文件失败:', error)
    throw error
  }
} 